1
00:00:03,360 --> 00:00:10,530
我知道您很兴奋，因为您一直期待着整个部分的错误搜寻

2
00:00:10,530 --> 00:00:14,790
线性代数，如果你还没有的话，我们就开始吧。

3
00:00:15,090 --> 00:00:22,500
现在是暂停视频、浏览所有代码并查找并修复所有错误的时候了。

4
00:00:22,830 --> 00:00:23,370
好的。

5
00:00:23,370 --> 00:00:31,050
所以我已经可以看到我们需要从导入一些模块和特殊函数开始。

6
00:00:31,360 --> 00:00:32,910
那么让我们看看。

7
00:00:33,450 --> 00:00:44,160
我们需要 import numty as 和 P，我们需要 import simpy as SIM，我们需要导入 from

8
00:00:44,550 --> 00:00:51,390
AI Python，显示显示和数学功能。

9
00:00:51,810 --> 00:00:52,920
也许我们会需要。

10
00:00:52,920 --> 00:00:55,610
哦，我们肯定需要 matplotlib，现在我在这里看到它。

11
00:00:55,950 --> 00:01:04,260
因此，还将 matplotlib dot pi 图导入为 p l t..

12
00:01:04,770 --> 00:01:05,300
好吧。

13
00:01:05,310 --> 00:01:08,670
我认为这可能是我们需要的所有模块。

14
00:01:09,030 --> 00:01:09,520
让我们来看看。

15
00:01:09,540 --> 00:01:11,700
创建一个列向量，然后。

16
00:01:11,700 --> 00:01:15,720
哦，这里嵌入了很多复杂的函数。

17
00:01:16,200 --> 00:01:17,430
让我们看看会发生什么。

18
00:01:17,510 --> 00:01:17,850
唔。

19
00:01:18,390 --> 00:01:18,770
好的。

20
00:01:18,780 --> 00:01:24,090
首先，这里有这些双方括号看起来有点尴尬，但这是

21
00:01:24,090 --> 00:01:26,120
显然也不是列向量。

22
00:01:26,130 --> 00:01:27,780
它应该是一个列向量。

23
00:01:28,650 --> 00:01:35,610
好吧，这里发生的是，当您使用数字键盘指定矩阵时，矩阵中的每一行

24
00:01:35,790 --> 00:01:39,540
数组中，每一行都需要放在自己的方括号中。

25
00:01:39,570 --> 00:01:46,250
所以这需要放在方括号中，三个需要放在方括号中。

26
00:01:46,260 --> 00:01:50,130
所以和其他括号一样，我认为我们只是为了让我们感到困惑。

27
00:01:50,640 --> 00:01:56,580
所以我们开始，每一行都在自己的方括号中，然后整个矩阵位于一组正方形中

28
00:01:56,580 --> 00:01:59,010
括号给我们一个列向量。

29
00:01:59,880 --> 00:02:00,440
好的。

30
00:02:00,870 --> 00:02:04,550
可视化标量向量乘法。

31
00:02:04,590 --> 00:02:04,980
让我们来看看。

32
00:02:04,990 --> 00:02:07,920
我只是要运行这个，然后我们收到一个错误。

33
00:02:08,490 --> 00:02:11,220
实际上，这有点棘手。

34
00:02:11,230 --> 00:02:14,790
所以我们说错误消息声称在这一行。

35
00:02:15,810 --> 00:02:21,590
如果您查看错误消息本身，它会显示字符串对象不可调用。

36
00:02:21,960 --> 00:02:23,000
那么这是怎么回事呢？

37
00:02:23,010 --> 00:02:25,470
这一行实际上没有任何字符串。

38
00:02:26,100 --> 00:02:27,620
所以这真的很棘手。

39
00:02:27,630 --> 00:02:34,500
这里的错误，错误实际上发生在这行代码上，以及我在这里做错了什么。

40
00:02:34,530 --> 00:02:40,620
好吧，你知道，无论谁写了这段代码，写了这段代码的可怕程序员，他们是什么

41
00:02:40,620 --> 00:02:43,650
尝试做的是将访问设置为方形。

42
00:02:44,250 --> 00:02:49,330
但事实上，他们所做的是将轴设置为字符串变量。

43
00:02:50,040 --> 00:02:59,250
所以我们需要做的就是像这样把它放在括号里，但现在我们实际上仍然得到这个错误。

44
00:02:59,460 --> 00:03:06,670
基本上这里发生的事情是我们刚刚通过设置对访问造成了一些真正的根本损害

45
00:03:06,670 --> 00:03:09,210
它等于字符串是正方形的。

46
00:03:09,570 --> 00:03:16,050
而且，你知道，有时当你真的将 Python 代码全部集中在一个包中时，这很好

47
00:03:16,050 --> 00:03:17,450
只是为了重新开始一切。

48
00:03:17,460 --> 00:03:22,190
所以我要选择此处的 Col 并重新启动它。

49
00:03:22,200 --> 00:03:23,970
它说：您确定要重新启动吗？

50
00:03:23,970 --> 00:03:25,800
所有变量都将丢失。

51
00:03:26,100 --> 00:03:30,500
现在，有时这是有问题的，但在这里没有问题。

52
00:03:30,720 --> 00:03:37,110
我们需要做的就是在此处重新运行此单元以重新导入所有这些模块。

53
00:03:38,210 --> 00:03:40,920
好的，然后我要回去重新运行这个。

54
00:03:41,270 --> 00:03:46,370
现在绘图部分看起来不错，但图例看起来不太正确。

55
00:03:46,370 --> 00:03:48,390
所以我不知道这个百分比在这里做什么。

56
00:03:48,410 --> 00:03:52,780
这实际上只是红色的矢量 V 和 S.V..

57
00:03:52,790 --> 00:03:55,180
所以我认为我们甚至不需要那个百分号。

58
00:03:55,660 --> 00:03:59,860
好的，现在让我们看看这里发生了什么，以确保我们做的是正确的事情。

59
00:04:00,080 --> 00:04:06,800
所以我们这里有这个向量，减二等于减两个逗号而不减二。

60
00:04:07,190 --> 00:04:10,280
这里的标量是零点七。

61
00:04:10,700 --> 00:04:17,000
现在，如果向量是负二加二，也就是这条线，标量是零点七，

62
00:04:17,120 --> 00:04:20,480
那么实际上这条蓝线可能应该到达这里附近。

63
00:04:20,480 --> 00:04:21,690
不应该是点。

64
00:04:21,740 --> 00:04:24,500
我认为这里有根本性的错误。

65
00:04:24,770 --> 00:04:28,620
让我们也看看这个变量 S.V.实际上是。

66
00:04:28,640 --> 00:04:33,350
因此，如果我们打印出 S.V.，那么它只是一个零。

67
00:04:34,190 --> 00:04:37,670
这实际上不是这个向量乘以第七点。

68
00:04:38,000 --> 00:04:39,140
那么这是怎么回事呢？

69
00:04:39,140 --> 00:04:44,060
实际上，我不知道这里发生了什么，但看起来我们正在计算 DOT 乘积

70
00:04:44,060 --> 00:04:45,580
南非国家电力公司之间。

71
00:04:45,620 --> 00:04:51,530
S，所以一个向量是点七点七减二加二。

72
00:04:51,960 --> 00:04:54,500
现在这个结果的来源实际上是有道理的。

73
00:04:54,780 --> 00:05:02,180
本质上，我们在这里所做的是说点七次减二加点七次加

74
00:05:02,180 --> 00:05:03,540
二等于零。

75
00:05:03,830 --> 00:05:05,640
所以这是完全错误的。

76
00:05:05,660 --> 00:05:12,520
这实际上应该是 S 乘 V 这样。

77
00:05:13,220 --> 00:05:16,490
现在，当我们打印出来时，我们看到我们得到了我们所期望的结果。

78
00:05:16,520 --> 00:05:22,660
所以点七乘以二等于一点四，然后我们就得到了这个向量的缩放版本。

79
00:05:23,000 --> 00:05:26,330
当然，现在我们已经收到了一些其他错误和这一行的错误。

80
00:05:26,840 --> 00:05:34,280
你实际上可以看到，这就是你知道的，我们需要这里的第一个组件和第二个组件

81
00:05:34,280 --> 00:05:34,670
在这里。

82
00:05:36,860 --> 00:05:39,350
这应该是第二个组件的一个。

83
00:05:39,920 --> 00:05:40,750
好的。

84
00:05:40,760 --> 00:05:42,500
现在，这看起来不错。

85
00:05:42,800 --> 00:05:48,150
我想说的是，这就是这个特定问题的成功完成。

86
00:05:49,040 --> 00:05:49,450
好的。

87
00:05:49,460 --> 00:05:56,330
所以我们开始计算点积的算法，这样我们就有一些随机向量，然后我们做

88
00:05:56,780 --> 00:06:05,720
点积通过将点积设置为此变量为零，并将相应的值添加到自身

89
00:06:05,720 --> 00:06:11,510
V 中的元素乘以 W，然后我们将其与函数 num num, pi, dot 进行比较。

90
00:06:12,380 --> 00:06:12,820
好的。

91
00:06:12,830 --> 00:06:15,710
所以我们已经得到一个错误，这与形状有关。

92
00:06:15,730 --> 00:06:21,830
所以我希望你已经抓住了这个，这样你就可以将其更改为七个，或者你可以更改

93
00:06:21,830 --> 00:06:22,410
到八点。

94
00:06:22,460 --> 00:06:23,620
不管怎样，都可以。

95
00:06:24,810 --> 00:06:25,160
唔。

96
00:06:25,260 --> 00:06:30,990
现在，这两个答案实际上并不相等，这是怎么回事？

97
00:06:31,350 --> 00:06:35,980
好吧，如果我们仔细看看这行代码，看起来这是一个拼写错误。

98
00:06:36,000 --> 00:06:37,920
这大概应该说我。

99
00:06:38,220 --> 00:06:43,590
否则，它被固定为向量 W 中的第一个或第二个元素。

100
00:06:44,440 --> 00:06:44,940
让我们看看。

101
00:06:44,950 --> 00:06:49,170
现在我们对这两种机制都得到了相同的答案。

102
00:06:49,950 --> 00:06:54,630
现在我想向您展示一些 Python 中实现此功能的快捷方式。

103
00:06:55,140 --> 00:07:02,130
因此，如果您想将变量设置为等于其自身加上其他值，您可以写出以下行

104
00:07:02,130 --> 00:07:03,980
像这样的代码完全没问题。

105
00:07:03,990 --> 00:07:05,730
我认为这看起来非常清楚。

106
00:07:06,060 --> 00:07:12,750
然而，可以用更简洁的语言写出来，那就是说 plus

107
00:07:12,750 --> 00:07:15,000
等于而不是仅仅等于。

108
00:07:15,570 --> 00:07:23,760
所以 Python 会在这里将此表达式解释为 DOT 乘积等于其自身加上任意值

109
00:07:23,760 --> 00:07:25,800
位于该等式的右侧。

110
00:07:26,430 --> 00:07:27,440
你可以在这里看到这一点。

111
00:07:27,450 --> 00:07:34,300
现在我再次运行此程序，您会得到与 NPR 点和我们的算法相同的答案。

112
00:07:35,160 --> 00:07:40,380
现在，显然，每次运行时这些答案都会改变，因为这些是随机数。

113
00:07:41,070 --> 00:07:41,770
很不错。

114
00:07:42,030 --> 00:07:42,770
让我们来看看。

115
00:07:43,770 --> 00:07:48,570
这并没有确切地告诉我们应该在这里做什么，但我可以往下看。

116
00:07:48,580 --> 00:07:55,800
因此，我们在这里创建一些数据作为从零到九的数字范围。

117
00:07:56,070 --> 00:07:59,550
然后我们添加一些正态分布的随机数。

118
00:07:59,910 --> 00:08:05,590
这里我们计算相关性并通过相关系数与数字进行确认。

119
00:08:05,640 --> 00:08:10,140
好的，所以我希望这两个变量彼此相同。

120
00:08:10,470 --> 00:08:14,820
我猜它们有点接近，但肯定不完全相同。

121
00:08:15,300 --> 00:08:16,480
让我们看看出了什么问题。

122
00:08:17,010 --> 00:08:23,850
所以请记住我在视频中展示的有关计算的相关系数，这是一个

123
00:08:23,850 --> 00:08:31,260
DOT积在统计中的应用，相关系数的分子是

124
00:08:31,260 --> 00:08:37,620
两个向量和分母之间的点积是点积的平方根

125
00:08:37,620 --> 00:08:43,770
向量与其自身乘以另一个向量与其自身的点积的平方根。

126
00:08:44,100 --> 00:08:46,190
然后我们进行这个划分。

127
00:08:46,200 --> 00:08:48,570
所以实际上所有这些都是正确的。

128
00:08:48,570 --> 00:08:51,080
然而，我们错过了一件事。

129
00:08:51,090 --> 00:08:56,910
我们缺少的一件事是什么，我们缺少的一件事是这些数据向量，

130
00:08:56,910 --> 00:09:02,300
这些数据流需要以平均值为中心，因此意味着中心。

131
00:09:02,610 --> 00:09:07,110
这仅仅意味着从数据集中减去平均值。

132
00:09:07,120 --> 00:09:13,500
所以数据一等于数据一减去数字，我的意思是数据一。

133
00:09:14,020 --> 00:09:19,080
现在，如果您已经认为这可以简化，那么对您有好处。

134
00:09:19,260 --> 00:09:21,570
我们将这样做。

135
00:09:22,830 --> 00:09:31,170
现在这是数据一，然后我们也对数据重复此操作，现在我们得到完全相同的结果

136
00:09:31,170 --> 00:09:34,830
这两个操作的相关系数。

137
00:09:35,370 --> 00:09:40,740
事实上，有趣的是，一旦你减少到大约 10 或 12 或其他什么，这就是

138
00:09:40,980 --> 00:09:46,230
精度，最终这些算法确实开始出现一点点分歧。

139
00:09:46,500 --> 00:09:52,500
那是因为这个函数的 kuriko 实际上实现了一个稍微不同且更高效的

140
00:09:52,500 --> 00:09:55,740
和比我在这里展示的算法更快的算法。

141
00:09:56,100 --> 00:09:57,410
好吧，我们开始吧。

142
00:09:57,420 --> 00:10:04,410
我们正在尝试计算外积，这看起来又像其中一种方法

143
00:10:04,410 --> 00:10:07,560
我们比较 numties 函数 outr。

144
00:10:07,650 --> 00:10:15,510
因此，内置函数 outr 可以使用计算外部的算法手动计算此值

145
00:10:15,510 --> 00:10:15,960
产品。

146
00:10:16,350 --> 00:10:23,460
因此请记住，计算外积的一种方法是设置外积矩阵的每一行

147
00:10:23,850 --> 00:10:26,960
是右矩阵的行。

148
00:10:26,970 --> 00:10:33,840
右向量也是如此，它将是左向量每个元素的 this 倍，即

149
00:10:33,840 --> 00:10:35,280
这里看起来像一个。

150
00:10:36,060 --> 00:10:39,260
所以这已经告诉我这里出了问题。

151
00:10:39,810 --> 00:10:41,790
那么让我们尝试运行这个。

152
00:10:41,790 --> 00:10:44,550
这表示无法广播输入。

153
00:10:44,560 --> 00:10:44,760
正确的。

154
00:10:44,790 --> 00:10:52,050
好的，根据我刚才描述的计算外积矩阵的算法，我可以

155
00:10:52,050 --> 00:10:54,830
已经确定这是不正确的。

156
00:10:54,840 --> 00:11:02,220
这应该是右侧的整个行向量和左侧的列向量的每个元素

157
00:11:02,340 --> 00:11:02,960
像这样。

158
00:11:03,810 --> 00:11:04,260
唔。

159
00:11:04,290 --> 00:11:08,700
所以现在我们没有收到任何明确的 python 错误。

160
00:11:09,060 --> 00:11:18,240
但是当我说外部时，这里的外部乘积矩阵减去 num 外部，我们得到零

161
00:11:18,240 --> 00:11:22,680
前四行，最后四行为非零。

162
00:11:23,130 --> 00:11:26,040
所以这里显然发生了一些奇怪的事情。

163
00:11:26,070 --> 00:11:26,910
让我们再试一次。

164
00:11:27,820 --> 00:11:28,230
唔。

165
00:11:28,440 --> 00:11:29,580
再次，同样的事情。

166
00:11:29,610 --> 00:11:35,070
所以现在我们得到前四行的全零和这里的几个零。

167
00:11:35,340 --> 00:11:39,880
但前四行零似乎非常一致。

168
00:11:40,380 --> 00:11:44,050
我想知道如果我改变这些矩阵的大小会发生什么。

169
00:11:44,070 --> 00:11:49,470
那么假设这是六个元素而这是八个元素怎么办？

170
00:11:50,050 --> 00:11:57,240
哦，现在我们确实收到一条错误消息，它说索引六超出了零轴的范围

171
00:11:57,240 --> 00:11:57,960
尺寸六。

172
00:11:58,020 --> 00:12:03,160
好的，实际发生的事情是在范围的这一行中。

173
00:12:03,510 --> 00:12:09,060
现在，请注意，我们实际上循环的是元素合一。

174
00:12:09,480 --> 00:12:15,270
但是我们在这里循环，我们指定的是元素的范围实际上是

175
00:12:15,450 --> 00:12:17,250
来自O2的大小。

176
00:12:18,240 --> 00:12:21,150
所以我打算把两个替换为一个。

177
00:12:21,330 --> 00:12:23,460
现在我们得到一个全零的矩阵。

178
00:12:23,700 --> 00:12:32,100
但这是一个非常棘手的问题，因为，你知道，当事情是这样的时候，所以最初是这样的，

179
00:12:32,580 --> 00:12:37,680
我们没有遇到任何 python 编码错误，因为从技术上讲我们没有做任何错误

180
00:12:37,680 --> 00:12:38,400
编程。

181
00:12:38,640 --> 00:12:44,550
我们在数学和索引方面做了一些错误的事情，但我们在以下方面没有做任何非法的事情：

182
00:12:44,550 --> 00:12:45,930
python 编码术语。

183
00:12:46,380 --> 00:12:47,610
但结果是错误的。

184
00:12:47,610 --> 00:12:53,510
如果你没有真正进行比较，那么，是的，你可能根本不会注意到。

185
00:12:53,520 --> 00:12:56,020
您甚至可能没有注意到这个错误在那里。

186
00:12:56,400 --> 00:13:00,480
所以这些是最狡猾的编码错误。

187
00:13:00,760 --> 00:13:02,040
无论如何，让我们继续吧。

188
00:13:02,790 --> 00:13:04,860
好的，矩阵乘法。

189
00:13:05,130 --> 00:13:08,370
所以我们有一个随机的五乘五矩阵。

190
00:13:08,370 --> 00:13:12,000
将其乘以五乘五单位矩阵。

191
00:13:12,270 --> 00:13:18,210
我们应该看到的是一个完整的随机数矩阵，但我们没有看到。

192
00:13:18,210 --> 00:13:21,380
事实上，我们看到一个大部分为零的矩阵。

193
00:13:21,900 --> 00:13:28,500
所以这里发生的是星号正在实现元素 Y 的乘法，但我们需要

194
00:13:28,830 --> 00:13:31,190
完整的矩阵乘法。

195
00:13:31,650 --> 00:13:32,730
所以就这样吧。

196
00:13:33,600 --> 00:13:35,430
好吧，让我们继续到下一个单元格。

197
00:13:35,440 --> 00:13:38,220
看起来这是一个类似的问题。

198
00:13:38,220 --> 00:13:44,340
所以我已经可以看出，将 a 乘以单位矩阵有点奇怪。

199
00:13:45,590 --> 00:13:54,110
所以在这里我们看到原始的矩阵 A。这里我们正在进行元素 Y 的乘法，这表示有

200
00:13:54,110 --> 00:13:55,540
其实是尺寸问题。

201
00:13:56,120 --> 00:14:02,180
因此，对于元素 Y 的乘法，这两个矩阵是不可能的，因为它们是不同的

202
00:14:02,180 --> 00:14:02,680
尺寸。

203
00:14:02,690 --> 00:14:04,250
它们具有不同数量的元素。

204
00:14:04,580 --> 00:14:09,220
那么让我们看看如果我们用矩阵乘法替换它会发生什么。

205
00:14:09,650 --> 00:14:10,430
就这样吧。

206
00:14:10,440 --> 00:14:19,460
我们知道顶部的 a 与矩阵乘以底部的单位矩阵是一样的

207
00:14:19,460 --> 00:14:19,730
在这里。

208
00:14:19,760 --> 00:14:23,810
所以你可以看到这个矩阵和这个矩阵是一样的。

209
00:14:24,750 --> 00:14:25,780
好吧在这里。

210
00:14:26,640 --> 00:14:31,090
这个说随机矩阵是可转换的。

211
00:14:31,340 --> 00:14:37,130
所以我们要做的就是创建一个由负五到正五之间的随机整数组成的矩阵。

212
00:14:37,440 --> 00:14:39,950
它是五乘五并且是随机的。

213
00:14:39,960 --> 00:14:41,310
所以应该是可以兑换的。

214
00:14:41,310 --> 00:14:44,180
所以我真的不明白这里有什么问题。

215
00:14:44,190 --> 00:14:50,430
我们应该得到单位矩阵，因为矩阵乘以它的逆矩阵就是单位矩阵。

216
00:14:50,460 --> 00:14:51,390
让我们看看发生了什么事。

217
00:14:52,740 --> 00:15:01,530
嗯，模块号 II 没有属性，这里的问题是它不在主 PI 模块中，

218
00:15:01,800 --> 00:15:06,240
它实际上位于 Lynn alg 模块或子模块中。

219
00:15:06,960 --> 00:15:12,960
好的，现在我们将 a 乘以它的逆矩阵，得到单位矩阵。

220
00:15:14,650 --> 00:15:22,330
让我们看看，这里我们绘制 Igen 谱，所以我们创建一个矩阵，乘以该矩阵

221
00:15:22,330 --> 00:15:27,550
请记住，通过它自己的转置，这给了我们一个对称方阵。

222
00:15:27,560 --> 00:15:31,510
这个矩阵已经是方形的，但它确实给了我们一个对称矩阵。

223
00:15:32,020 --> 00:15:33,990
让我们看看这里发生了什么。

224
00:15:35,320 --> 00:15:37,500
所以我们不会收到任何 python 错误。

225
00:15:37,510 --> 00:15:39,120
所以这部分看起来没问题。

226
00:15:39,610 --> 00:15:41,800
但让我们看看这些特征值。

227
00:15:41,800 --> 00:15:48,670
您知道，大约有 25 个这样的特征值，但这只是一个 5 x 5 矩阵，我们可以

228
00:15:48,670 --> 00:15:49,570
甚至确认这一点。

229
00:15:49,570 --> 00:15:57,250
所以我要打印出 num pi，M 的形状，这是一个五乘五的矩阵。

230
00:15:57,250 --> 00:16:01,120
所以实际上应该只有五个特征值。

231
00:16:01,150 --> 00:16:02,370
让我们看看发生了什么事。

232
00:16:02,650 --> 00:16:10,100
我将查看 IG 的帮助文件或停靠字符串，看看这是否能给我们一些见解。

233
00:16:10,480 --> 00:16:19,510
所以这返回 W 是特征值，然后 V 第二个输出是 Igen 向量。

234
00:16:19,870 --> 00:16:22,610
所以实际上这里的输出顺序是错误的。

235
00:16:22,630 --> 00:16:23,620
这是刚换的。

236
00:16:23,890 --> 00:16:29,260
这应该是特征值，这应该是特征向量。

237
00:16:30,490 --> 00:16:36,850
现在我们只得到五个组件，这里绘制了五个内容，这是一致的。

238
00:16:36,850 --> 00:16:40,810
这正是我们期望的特征值。

239
00:16:41,340 --> 00:16:44,470
顺便说一句，我还没有向您介绍这个功能。

240
00:16:44,470 --> 00:16:47,740
展平 num pi 矩阵，点展平。

241
00:16:48,160 --> 00:16:54,850
但本质上，它所做的就是采用这个矩阵或任何输入矩阵并展开

242
00:16:54,850 --> 00:16:59,130
它从一个矩阵变成一个非常长的数组，一个非常长的向量。

243
00:16:59,800 --> 00:17:06,730
因此，对于特征向量矩阵，这是一个五乘五的矩阵，当你压平它时，你会得到

244
00:17:06,730 --> 00:17:12,730
总共 25 个元素，这就是为什么这里有 25 个元素。

245
00:17:12,740 --> 00:17:18,520
所以这些只是所有五个特征向量中每一个的所有单独组成部分。

246
00:17:18,790 --> 00:17:22,180
好的，所以把它放回去，这样看起来更好。

247
00:17:23,080 --> 00:17:29,380
顺便说一句，您还可以在这里看到特征值本质上并不是按大小排序的，

248
00:17:29,680 --> 00:17:37,000
所以它们首先不会作为最大特征值出现，这与估计算法有关

249
00:17:37,000 --> 00:17:40,300
Python 用于计算特征值。

250
00:17:40,870 --> 00:17:42,600
无论如何，让我们继续吧。

251
00:17:42,640 --> 00:17:47,090
这看起来像是寻找 bug 的最后一个练习。

252
00:17:47,530 --> 00:17:51,670
所以看起来我们正在创建一个随机整数矩阵。

253
00:17:51,970 --> 00:17:53,690
这是一个 10 x 20 的矩阵。

254
00:17:53,690 --> 00:17:58,450
所以实际上我们不能对这个矩阵进行特征值分解。

255
00:17:58,450 --> 00:18:00,660
当然，我们可以做 SVOD。

256
00:18:01,240 --> 00:18:02,580
所以我们制作DVD。

257
00:18:03,400 --> 00:18:11,080
我们根据这些奇异值创建一个基于对角矩阵的完整矩阵。

258
00:18:11,350 --> 00:18:15,700
然后我们尝试重建该矩阵并绘制一些图。

259
00:18:16,150 --> 00:18:16,510
好的。

260
00:18:16,520 --> 00:18:19,720
我们已经收到一个错误，它与大小有关。

261
00:18:20,000 --> 00:18:27,200
事实上，这就是我在之前关于奇异值分解的视频中讨论过的内容。

262
00:18:27,610 --> 00:18:36,010
所以我们需要做的是首先将其重建为与大小或

263
00:18:36,010 --> 00:18:48,550
矩阵 A 的形状，然后我们需要循环 S 中的元素，因此长度范围为 s，然后

264
00:18:48,550 --> 00:18:55,510
我们说 s 第 i 个对角元素等于小 S 中的相应元素。

265
00:18:55,540 --> 00:18:56,620
所以在向量 s 中。

266
00:18:57,290 --> 00:18:59,380
好的，现在让我们看看它是什么样子的。

267
00:18:59,890 --> 00:19:01,510
哦，我们仍然收到错误。

268
00:19:01,790 --> 00:19:03,810
这是另一个不匹配的维度。

269
00:19:03,820 --> 00:19:04,090
嘿。

270
00:19:04,090 --> 00:19:10,960
但你知道，看顺序，这不是正确的顺序，应该是U乘Sigma Times

271
00:19:10,960 --> 00:19:19,990
V所以我要像这样重写这个你时间Sigma Times V实际上这是V转置python

272
00:19:19,990 --> 00:19:22,720
会自动吐出V transpose。

273
00:19:24,130 --> 00:19:25,860
好的，这看起来不错。

274
00:19:25,870 --> 00:19:32,230
这里我们看到Matrix A、重建的矩阵A以及两者之间的差异，即

275
00:19:32,230 --> 00:19:33,070
一块空地。

276
00:19:33,070 --> 00:19:33,940
都是零。

277
00:19:34,090 --> 00:19:38,980
这令人欣慰，因为这意味着我们已经准确地重建了这个矩阵。

278
00:19:40,070 --> 00:19:45,770
我希望你喜欢这次 bug 搜寻，更广泛地说，我希望你喜欢学习一些关于

279
00:19:45,770 --> 00:19:48,980
课程这一部分的线性代数。

280
00:19:49,460 --> 00:19:55,610
正如我在本节开头提到的，线性代数是一门美丽、丰富且非常重要的学科。

281
00:19:55,610 --> 00:19:56,880
数学中的话题。

282
00:19:57,140 --> 00:20:02,450
我希望你对学习线性有一点品味和热情

283
00:20:02,450 --> 00:20:03,830
本节的代数。

284
00:20:04,400 --> 00:20:09,440
也许您会受到启发继续更深入地学习线性代数。